Randomized Parallel Proof-Number Search1

Most computer programs for board games successfully employ αβ search. For some games, however, αβ search displays a weakness in the endgame that can currently neither be overcome by endgame databases nor by other αβ extensions. To remedy the deficit, mate searches may be applied. One such alternative to αβ search is Proof-Number Search (PNS). PNS enjoys popularity as a powerful method for solving endgame positions and complete games. Since its introduction by Allis et al. [2] in 1994, PNS has developed into a whole family of search algorithms (e.g., PN [1], PDS [6], and df-pn [7]) with applications to many games, such as Shogi [9], the one-eye problem in Go [5], Checkers [8], and Lines of Action [11]. A variety of parallel αβ algorithms have been proposed in the past [3], but so far not much research has been conducted on parallelizing PNS. With multi-core processors becoming established as standard equipment, parallelizing PNS has become an important topic. Pioneering research has been conducted by Kishimoto [4], who parallelized the depth-first PNS variant PDS. His algorithm is called ParaPDS and is designed for distributed memory systems. In this abstract we address the problem of parallelizing PNS and PN for shared memory systems. We solved this problem by introducing a new parallel Proof-Number Search algorithm for shared memory systems, called Randomized Parallel Proof-Number Search (RP–PNS). It adheres to the principle of randomized parallelization [10]. The method relies on a heuristic which may seem counterintuitive at first. Instead of selecting the child with the best heuristic evaluation, a probability distribution of the children determines which node is selected. This is called the randomization of the move selection. The specific probability distribution is based on the selection heuristic. The parallelization is now achieved by threads that select moves close to the principal variation based on the probability distribution. The same principle can be applied to the two-level variant of PNS, also known as PN. The resulting algorithm is then called RP–PN. We evaluated RP–PNS and RP–PNon a test set consisting of 143 complex Lines-of-Action endgame positions. Two series of experiments were conducted. The first series tested the efficiency of RP–PNS; the second tested the efficiency of RP–PN. In the first series of experiments we tested the performance of RP–PNS for solving the positions. The results regarding time, nodes evaluated, and nodes in memory for 1, 2, 4, and 8 threads are given in the upper part of Table 1. We observe that the scaling factor for 2, 4, and 8 threads is 1.6, 2.5, and 3.5, respectively. Based on the results we computed that the search overhead expressed by the number of nodes evaluated is only ca. 33% for 8 threads. It means that the synchronization overhead is responsible for the largest part of the total overhead. Finally, we see that RP–PNS8 uses 50% more memory than PNS. In the second series of experiments we tested the performance of RP–PN. The results regarding time, nodes evaluated, and nodes in memory for 1, 2, 4, and 8 threads are given in the lower part of Table 1. We observe that the scaling factor for 2, 4, and 8 threads is 1.9, 3.4, and 4.7, respectively. Compared to RP–PNS the relative scaling factor of RP–PN is better for all configurations. The search overhead of RP–PN8 is 27% which is comparable to the search overhead of RP–PNS8. At the same time the total overhead of RP–PN8 is smaller. This means that the synchronization overhead is smaller for RP–PN 2 8 than for RP–PNS8. The reason is that more time is spent in the second-level trees. Therefore, the probability that two threads simultaneously try to lock the same node of the first-level tree is reduced. Finally, we